#include <boost/container/vector.hpp>
#include <boost/intrusive/list.hpp>
// #include <boost/container/multimap.hpp>
#include <boost/container/flat_set.hpp>
#include <boost/container/flat_map.hpp>
#include <boost/container/small_vector.hpp>
#include <boost/container/set.hpp>
#include <boost/container/list.hpp>
#include <boost/container/deque.hpp>
#include <boost/container/map.hpp>
#include <boost/container/pmr/vector.hpp>
#include <boost/container/pmr/monotonic_buffer_resource.hpp>

#include <boost/multi_index_container.hpp>
#include <boost/multi_index/ordered_index.hpp>
#include <boost/multi_index/member.hpp>
#include <boost/container/pmr/monotonic_buffer_resource.hpp>

#include <boost/archive/text_oarchive.hpp>
#include <boost/archive/text_iarchive.hpp>
#include <boost/serialization/vector.hpp>
#include <boost/pool/pool_alloc.hpp>

#include <boost/range/algorithm.hpp>
#include <boost/lockfree/queue.hpp>

#include <boost/container/allocator_traits.hpp>

#include <memory>
#include <iostream>
#include <string>
#include <sstream>
#include <thread>
#include <atomic>
#include <utility>

#include <type_traits>
#include <iterator>


int main() {
    boost::container::set<int> set1 = {1, 3, 5};
    boost::container::set<int> set2 = {2, 4, 6};

    // 合并 set2 到 set1
    set1.merge(set2);

    std::cout << "合并后，set1 中的元素: ";
    for (const auto& val : set1) {
        std::cout << val << " ";
    }
    std::cout << std::endl;

    std::cout << "合并后，set2 是否为空: " << (set2.empty() ? "是" : "否") << std::endl;

    return 0;
}

// int main() {
//     boost::container::list<int> list1 = {1, 2, 3};
//     boost::container::list<int> list2 = {4, 5, 6};

//     // 将 list2 的元素移动到 list1 的末尾
//     list1.splice(list1.end(), list2);

//     std::cout << "list1 中的元素: ";
//     for (const auto& val : list1) {
//         std::cout << val << " ";
//     }
//     std::cout << std::endl;

//     std::cout << "list2 是否为空: " << (list2.empty() ? "是" : "否") << std::endl;

//     return 0;
// }

// int main() {
//     boost::container::map<int, std::string> my_map;

//     // 插入第一个元素，没有提示
//     auto hint = my_map.emplace_hint(my_map.end(), 10, "十");
//     std::cout << "插入键 10 后: ";
//     for (const auto& pair : my_map) {
//         std::cout << "(" << pair.first << ", " << pair.second << ") ";
//     }
//     std::cout << std::endl;

//     // 插入第二个元素，提供正确的提示
//     my_map.emplace_hint(hint, 5, "五");
//     std::cout << "插入键 5 后: ";
//     for (const auto& pair : my_map) {
//         std::cout << "(" << pair.first << ", " << pair.second << ") ";
//     }
//     std::cout << std::endl;

//     return 0;
// }

// int main() {
//     boost::container::vector<int> vec;

//     // 预留容量
//     vec.reserve(10);
//     std::cout << "预留容量后，vector 的容量为: " << vec.capacity() << std::endl;

//     // 添加元素
//     vec.push_back(1);
//     vec.push_back(2);

//     // 缩小容量
//     vec.shrink_to_fit();
//     std::cout << "调整容量后，vector 的容量为: " << vec.capacity() << std::endl;

//     return 0;
// }


// int main() {
//     boost::container::vector<int> vec = {10, 20, 30, 40};

//     // 使用 erase 删除第二个元素
//     vec.erase(vec.begin() + 1);

//     std::cout << "删除元素后，vector 中的元素: ";
//     for (const auto& val : vec) {
//         std::cout << val << " ";
//     }
//     std::cout << std::endl;

//     // 清空容器
//     vec.clear();
//     std::cout << "清空容器后，vector 是否为空: " << (vec.empty() ? "是" : "否") << std::endl;

//     return 0;
// }

// int main() {
//     boost::container::vector<int> vec;

//     // 使用 insert
//     vec.insert(vec.end(), 10);
//     vec.insert(vec.end(), 20);

//     // 使用 emplace
//     vec.emplace(vec.end(), 30);

//     std::cout << "vector 中的元素: ";
//     for (const auto& val : vec) {
//         std::cout << val << " ";
//     }
//     std::cout << std::endl;

//     return 0;
// }

// int main() 
// {
//     boost::container::vector<int> vec = {10, 20, 30};

//     // 获取容器的 difference_type
//     using DifferenceType = boost::container::vector<int>::difference_type;

//     DifferenceType dist = std::distance(vec.begin(), vec.end());
//     std::cout << "迭代器之间的距离为: " << dist << std::endl;

//     return 0;
// }

// int main() {
//     boost::container::vector<int> vec = {10, 20, 30};

//     // 获取容器的 value_type
//     using ValueType = boost::container::vector<int>::value_type;

//     // 检查类型
//     if (std::is_same<ValueType, int>::value) {
//         std::cout << "容器存储的类型是 int" << std::endl;
//     }

//     // 使用 value_type 定义变量
//     ValueType new_element = 40;
//     vec.push_back(new_element);

//     std::cout << "容器中的元素: ";
//     for (const auto& val : vec) {
//         std::cout << val << " ";
//     }
//     std::cout << std::endl;

//     return 0;
// }

// int main() {
//     boost::container::vector<int> vec = {10, 20, 30};

//     // 使用 iterator 修改元素
//     for (boost::container::vector<int>::iterator it = vec.begin(); it != vec.end(); ++it) {
//         *it += 5; // 修改每个元素
//     }

//     // 使用 const_iterator 遍历元素
//     std::cout << "修改后的元素: ";
//     for (boost::container::vector<int>::const_iterator it = vec.cbegin(); it != vec.cend(); ++it) {
//         std::cout << *it << " ";
//     }
//     std::cout << std::endl;

//     return 0;
// }

// 自定义分配器
// template <typename T>
// class CustomAllocator {
// public:
//     using value_type = T;

//     T* allocate(std::size_t n) {
//         std::cout << "分配 " << n << " 个元素的内存" << std::endl;
//         return static_cast<T*>(::operator new(n * sizeof(T)));
//     }

//     void deallocate(T* p, std::size_t n) {
//         std::cout << "释放 " << n << " 个元素的内存" << std::endl;
//         ::operator delete(p);
//     }
// };

// int main() {
//     // 使用自定义分配器
//     boost::container::vector<int, CustomAllocator<int>> vec;

//     vec.push_back(10);
//     vec.push_back(20);

//     std::cout << "容器中的元素: ";
//     for (const auto& val : vec) {
//         std::cout << val << " ";
//     }
//     std::cout << std::endl;

//     return 0;
// }


// int main() {
//     // 创建一个 boost::container::set 容器，存储整数类型数据
//     boost::container::set<int> my_set;

//     // 插入元素
//     my_set.insert(10);
//     my_set.insert(20);
//     my_set.insert(15);

//     // 尝试插入重复元素
//     auto result = my_set.insert(10);
//     if (!result.second) {
//         std::cout << "元素 10 已存在，插入失败" << std::endl;
//     }

//     // 访问元素
//     std::cout << "set 中的元素（按升序排序）: ";
//     for (const auto& val : my_set) {
//         std::cout << val << " ";
//     }
//     std::cout << std::endl;

//     // 查找元素
//     auto it = my_set.find(15);
//     if (it != my_set.end()) {
//         std::cout << "找到元素 15" << std::endl;
//     } else {
//         std::cout << "未找到元素 15" << std::endl;
//     }

//     // 删除元素
//     my_set.erase(10);
//     std::cout << "删除元素 10 后，set 中的元素: ";
//     for (const auto& val : my_set) {
//         std::cout << val << " ";
//     }
//     std::cout << std::endl;

//     return 0;
// }



// int main() {
//     // 创建一个 boost::container::map 容器，存储键值对（整数到字符串的映射）
//     boost::container::map<int, std::string> my_map;


//     // 插入键值对
//     // my_map.insert(std::pair(1, "一"));
//     // my_map.insert(std::make_pair(3, "三"));
//     // my_map.insert(std::make_pair(2, "二"));
//     my_map.insert(std::make_pair(3, std::move(std::string("三"))));
//     my_map.insert(std::make_pair(1, std::move(std::string("一"))));
//     my_map.insert(std::make_pair(2, std::move(std::string("二"))));
//     my_map.emplace(4,"四");
//     my_map[5] = "五";


//     // 访问元素
//     std::cout << "map 中的元素（按键排序）: " << std::endl;
//     for (const auto& pair : my_map) {
//         std::cout << "键: " << pair.first << ", 值: " << pair.second << std::endl;
//     }

//     // 查找元素
//     auto it = my_map.find(2);
//     if (it != my_map.end()) {
//         std::cout << "找到键 2, 值为: " << it->second << std::endl;
//     } else {
//         std::cout << "未找到键 2" << std::endl;
//     }

//     // 删除元素
//     my_map.erase(1);
//     std::cout << "删除键 1 后，map 中的元素: " << std::endl;
//     for (const auto& pair : my_map) {
//         std::cout << "键: " << pair.first << ", 值: " << pair.second << std::endl;
//     }

//     return 0;
// }

// int main() {
//     // 创建一个 boost::container::list 容器，存储整数类型数据
//     boost::container::list<int> lst;

//     // 向列表中添加元素
//     lst.push_back(10);
//     lst.push_back(20);
//     lst.push_front(5);

//     // 访问元素
//     std::cout << "链表中的元素: ";
//     for (const auto& val : lst) {
//         std::cout << val << " ";
//     }
//     std::cout << std::endl;

//     // 插入和删除元素
//     auto it = lst.begin();
//     ++it;
//     lst.insert(it, 15); // 在第二个位置插入 15

//     std::cout << "插入元素 15 后，链表中的元素: ";
//     for (const auto& val : lst) {
//         std::cout << val << " ";
//     }
//     std::cout << std::endl;

//     // 删除元素
//     lst.erase(it); // 删除 20
//     std::cout << "删除元素 20 后，链表中的元素: ";
//     for (const auto& val : lst) {
//         std::cout << val << " ";
//     }
//     std::cout << std::endl;

//     return 0;
// }



// int main() {
//     // 创建一个 boost::container::deque 容器，存储整数类型数据
//     boost::container::deque<int> deq;

//     // 在头部和尾部插入元素
//     deq.push_back(10);
//     deq.push_back(20);
//     deq.push_front(5);

//     // 访问元素
//     std::cout << "双端队列中的元素: ";
//     for (const auto& val : deq) {
//         std::cout << val << " ";
//     }
//     std::cout << std::endl;

//     // 获取并修改元素
//     deq[1] = 50;
//     std::cout << "修改后，deq[1] = " << deq[1] << std::endl;

//     // 在头部和尾部删除元素
//     deq.pop_front();
//     deq.pop_back();

//     // 输出修改后的元素
//     std::cout << "删除头尾元素后，双端队列中的元素: ";
//     for (const auto& val : deq) {
//         std::cout << val << " ";
//     }
//     std::cout << std::endl;

//     return 0;
// }



//////////////////////////////////////////////////
//vector
/////////////////////////////////////////////////

// int main() {
//     // 创建一个 boost::container::vector 容器，存储整数类型数据
//     boost::container::vector<int> vec;

//     // 插入元素
//     vec.push_back(10);
//     vec.push_back(20);
//     vec.push_back(30);

//     // 访问元素
//     std::cout << "Elements in vector: ";
//     for (const auto& val : vec) {
//         std::cout << val << " ";
//     }
//     std::cout << std::endl;

//     // 获取并修改元素
//     vec[1] = 50;
//     std::cout << "After modification, vec[1] = " << vec[1] << std::endl;

//     // 动态调整大小
//     vec.resize(5, 100); // 调整大小为 5，并将新增元素初始化为 100
//     std::cout << "Elements after resize: ";
//     for (const auto& val : vec) {
//         std::cout << val << " ";
//     }
//     std::cout << std::endl;

//     // 删除元素
//     vec.pop_back(); // 删除最后一个元素
//     std::cout << "Elements after pop_back: ";
//     for (const auto& val : vec) {
//         std::cout << val << " ";
//     }
//     std::cout << std::endl;

//     return 0;
// }

//////////////////////////////////////////////////
//多态内存资源管理
/////////////////////////////////////////////////

// int main() {
//     // 创建一个单调缓冲资源，预分配 1024 字节的内存
//     char buffer[1024];
//     boost::container::pmr::monotonic_buffer_resource pool{buffer, sizeof(buffer)};

//     // 使用 PMR 分配器创建一个 vector
//     boost::container::pmr::vector<int> vec{&pool};

//     // 向 vector 中添加元素
//     vec.push_back(1);
//     vec.push_back(2);
//     vec.push_back(3);

//     // 输出 vector 中的元素
//     for (int n : vec) {
//         std::cout << n << ' ';
//     }
//     std::cout << '\n';

//     return 0;
// }

//////////////////////////////////////////////////
//move_traits
/////////////////////////////////////////////////

// struct MyStruct {
//     int a;
//     std::string b;

//     // 移动构造函数
//     MyStruct(int x, std::string y) : a(x), b(std::move(y)) {}
// };

// int main() {
//     boost::container::vector<MyStruct> vec;

//     MyStruct temp(10, "Boost Move");

//     // 使用 move_traits 来实现移动操作
//     vec.push_back(std::move(temp));

//     std::cout << "First element: " << vec[0].a << ", " << vec[0].b << std::endl;
//     // temp 现在处于未定义状态，输出空字符串
//     std::cout << "Temp after move: " << temp.b << std::endl;

//     return 0;
// }


//////////////////////////////////////////////////
//emplace
/////////////////////////////////////////////////

// struct MyStruct {
//     int a;
//     std::string b;

//     MyStruct(int x, std::string y) : a(x), b(std::move(y)) {}
// };

// int main() {
//     boost::container::vector<MyStruct> vec;

//     // 使用 emplace_back 原地构造 MyStruct
//     vec.emplace_back(1, "Boost Emplace");

//     std::cout << "First element: " << vec[0].a << ", " << vec[0].b << std::endl;

//     return 0;
// }

//////////////////////////////////////////////////
//move的支持
/////////////////////////////////////////////////

// int main() {
//     boost::container::vector<std::string> vec;

//     std::string str = "Boost Move Semantics";
    
//     // 使用移动语义避免拷贝
//     vec.push_back(std::move(str));

//     std::cout << "First element: " << vec[0] << std::endl;

//     // str 现在被置为未定义状态
//     std::cout << "Str after move: " << str << std::endl;  

//     return 0;
// }

//////////////////////////////////////////////////
//拓展分配器
/////////////////////////////////////////////////
// int main() {
//     // 使用 Boost 的 pool_allocator 来分配内存
//     boost::container::vector<int, boost::pool_allocator<int>> vec;

//     // 向 vector 中添加元素
//     vec.push_back(10);
//     vec.push_back(20);
//     vec.push_back(30);

//     // 输出 vector 中的元素
//     std::cout << "Vector contents: ";
//     for (const auto& val : vec) {
//         std::cout << val << " ";
//     }
//     std::cout << std::endl;

//     return 0;
// }



//////////////////////////////////////////////////
//拼接
/////////////////////////////////////////////////

// int main() {
//     // 创建两个 Boost 容器
//     boost::container::list<int> list1 = {1, 2, 3, 4};
//     boost::container::list<int> list2 = {5, 6, 7, 8};

//     // 输出原始容器内容
//     std::cout << "list1 before splice: ";
//     for (const auto& elem : list1) {
//         std::cout << elem << " "; 
//     }
//     std::cout << "\nlist2 before splice: ";
//     for (const auto& elem : list2) {
//         std::cout << elem << " ";  
//     }

//     // 使用 splice 方法进行常数时间范围拼接
//     list1.splice(list1.end(), list2);

//     // 输出拼接后的容器内容
//     std::cout << "\nlist1 after splice: ";
//     for (const auto& elem : list1) {
//         std::cout << elem << " ";  
//     }
//     std::cout << "\nlist2 after splice: ";
//     for (const auto& elem : list2) {
//         std::cout << elem << " ";  // 输出空容器
//     }

//     return 0;
// }

//////////////////////////////////////////////////
//线程安全的容器
/////////////////////////////////////////////////

// boost::lockfree::queue<int> q(100);  // 创建一个容量为 100 的无锁队列
// std::atomic<bool> done(false);

// void producer() {
//     for (int i = 0; i < 5; ++i) {
//         while (!q.push(i));  // 尝试将元素推入队列
//         std::cout << "Produced: " << i << std::endl;
//     }
//     done = true;
// }

// void consumer() {
//     int value;
//     while (!done || !q.empty()) {  // 继续消费直到生产者完成
//         if (q.pop(value)) {  // 从队列中取出一个元素
//             std::cout << "Consumed: " << value << std::endl;
//         }
//     }
// }

// int main() {
//     std::thread t1(producer);
//     std::thread t2(consumer);
    
//     t1.join();
//     t2.join();
    
//     return 0;
// }



//////////////////////////////////////////////////
//容器范围操作
/////////////////////////////////////////////////

// int main() {
//     boost::container::vector<int> vec = {1, 5, 2, 4, 3};
    
//     // 排序
//     boost::range::sort(vec);
    
//     // 输出排序后的容器
//     for (int val : vec) {
//         std::cout << val << " "; 
//     }
//     std::cout<<std::endl;

//     auto it = boost::range::find(vec, 3);  // 查找值为3的元素
//     if (it != vec.end()) {
//         std::cout << "Found: " << *it << std::endl;
//     }

//     boost::container::vector<int> vec1 = {1, 3, 5};
//     boost::container::vector<int> vec2 = {2, 4, 6};
//     boost::container::vector<int> result;
//     boost::range::merge(vec1, vec2, std::back_inserter(result));
//     std::cout<<"合并Vec1和vec2的结果为：";
//     for(auto val : result){
//         std::cout<<val<<" ";
//     }
//     std::cout<<std::endl;

//     boost::range::remove_if(vec, [](int val) { return val % 2 == 0; });
//     // 移除 vec 中所有偶数，留下的元素为 1, 3, 5


//     boost::range::reverse(vec);
//     std::cout<<"vec逆序后的结果为：";
//     for (int val : vec) {
//         std::cout << val << " "; 
//     }
//     std::cout<<std::endl;
 
//     return 0;
// }

//////////////////////////////////////////////////
//自定义比较行为
/////////////////////////////////////////////////

// struct CustomCompare {
//     bool operator()(const int& a, const int& b) const {
//         return a > b; // 自定义降序排序
//     }
// };

// int main() {
//     boost::container::set<int, CustomCompare> s;
//     s.insert(3);
//     s.insert(1);
//     s.insert(4);
    
//     for (int val : s) {
//         std::cout << val << " ";  
//     }
    
//     return 0;
// }



//////////////////////////////////////////////////
//容器序列化 
/////////////////////////////////////////////////

// namespace boost {
// namespace serialization {

// template <class Archive, class T>
// void serialize(Archive& ar, boost::container::vector<T>& vec, const unsigned int version) {
//     std::vector<T> temp(vec.begin(), vec.end());
//     ar & temp;
//     if (Archive::is_loading::value) {
//         vec.assign(temp.begin(), temp.end());
//     }
// }

// } // namespace serialization
// } // namespace boost

// int main() {
//     boost::container::vector<int> vec = {1, 2, 3, 4, 5};

//     // 序列化
//     std::stringstream ss;
//     boost::archive::text_oarchive oa(ss);
//     oa << vec;

//     // 反序列化
//     boost::container::vector<int> loaded_vec;
//     boost::archive::text_iarchive ia(ss);
//     ia >> loaded_vec;

//     std::cout << "Loaded vector: ";
//     for (int i : loaded_vec) {
//         std::cout << i << " ";
//     }
//     return 0;
// }


// int main() {
//     boost::container::vector<int> vec = {1, 2, 3, 4, 5};
    
//     // 序列化
//     std::stringstream ss;
//     boost::archive::text_oarchive oa(ss);
//     oa << vec;
    
//     // 反序列化
//     boost::container::vector<int> loaded_vec;
//     boost::archive::text_iarchive ia(ss);
//     ia >> loaded_vec;
    
//     std::cout << "Loaded vector: ";
//     for (int i : loaded_vec) {
//         std::cout << i << " ";
//     }
//     return 0;
// }




//////////////////////////////////////////////////
//stable_vector
/////////////////////////////////////////////////
// int main() {
//     boost::container::small_vector<int, 4> svec;  // 最多存储 4 个元素
    
//     svec.push_back(10);
//     svec.push_back(20);
//     svec.push_back(30);
    
//     for (const auto& val : svec) {
//         std::cout << val << std::endl;
//     }
    
//     return 0;
// }





//////////////////////////////////////////////////
//boost::container::flat_map
/////////////////////////////////////////////////
// int main() {
//     boost::container::flat_map<int, std::string> fmap;
    
//     fmap[1] = "one";
//     fmap[2] = "two";
//     fmap[3] = "three";
    
//     for (const auto& pair : fmap) {
//         std::cout << pair.first << ": " << pair.second << std::endl;
//     }
    
//     return 0;
// }


//////////////////////////////////////////////////
//1.自定义内存分配
/////////////////////////////////////////////////

// template <typename T>
// struct MyAllocator {
//     typedef T value_type;

//     MyAllocator() = default;

//     template <typename U>
//     MyAllocator(const MyAllocator<U>&) {}

//     T* allocate(std::size_t n) {
//         std::cout << "Allocating " << n << " elements.\n";
//         return static_cast<T*>(::operator new(n * sizeof(T)));
//     }

//     void deallocate(T* p, std::size_t n) {
//         std::cout << "Deallocating " << n << " elements.\n";
//         ::operator delete(p);
//     }
// };

// int main() {
//     boost::container::vector<int, MyAllocator<int>> v;
//     v.push_back(1);
//     v.push_back(2);
//     v.push_back(3);
//     return 0;
// }


//////////////////////////////////////////////////
//2.移动语义
/////////////////////////////////////////////////

// int main() {
//     boost::container::vector<int> vec1;
//     vec1.push_back(10);
//     vec1.push_back(20);
    
//     // 使用移动语义
//     boost::container::vector<int> vec2 = std::move(vec1);

//     std::cout << "vec2[0]: " << vec2[0] << std::endl; 
//     std::cout << "vec2[1]: " << vec2[1] << std::endl; 
//     std::cout << "vec1.size(): " << vec1.size() << std::endl; 
//     return 0;
// }

//////////////////////////////////////////////////
//3.原地构造
/////////////////////////////////////////////////

// struct MyStruct {
//     MyStruct(int x, int y) : a(x), b(y) {
//         std::cout << "MyStruct constructed\n";
//     }

//     int a, b;
// };

// int main() {
//     boost::container::vector<MyStruct> v;
    
//     // 使用 emplace_back 在容器内原地构造对象
//     v.emplace_back(10, 20); // 直接在容器内构造 MyStruct(10, 20)

//     std::cout << "v[0].a: " << v[0].a << std::endl; 
//     std::cout << "v[0].b: " << v[0].b << std::endl; 

//     return 0;
// }


//////////////////////////////////////////////////
//4.多重索引容器
/////////////////////////////////////////////////

// using namespace boost::multi_index;

// // 定义 Person 结构
// struct Person {
//     std::string name;
//     int age;

//     Person(std::string n, int a) : name(std::move(n)), age(a) {}
// };

// // 定义索引标签，用于区分不同的索引
// struct by_name {};
// struct by_age {};

// int main() {
//     // 使用 multi_index_container 创建多重索引容器
//     typedef multi_index_container<
//         Person,
//         indexed_by<
//             // 第一个索引用于按 name 排序
//             ordered_non_unique<
//                 tag<by_name>, 
//                 member<Person, std::string, &Person::name>
//             >,
//             // 第二个索引用于按 age 排序
//             ordered_non_unique<
//                 tag<by_age>, 
//                 member<Person, int, &Person::age>
//             >
//         >
//     > PersonContainer;

//     // 创建 PersonContainer 实例
//     PersonContainer people;
    
//     // 插入数据
//     people.insert(Person("Alice", 30));
//     people.insert(Person("Bob", 25));
//     people.insert(Person("Charlie", 30));
    
//     // 按 name 索引访问
//     std::cout << "People ordered by name:\n";
//     const auto& name_index = people.get<by_name>();
//     for (const auto& person : name_index) {
//         std::cout << person.name << ": " << person.age << " years old\n";
//     }

//     // 按 age 索引访问
//     std::cout << "\nPeople ordered by age:\n";
//     const auto& age_index = people.get<by_age>();
//     for (const auto& person : age_index) {
//         std::cout << person.name << ": " << person.age << " years old\n";
//     }

//     return 0;
// }

// struct Person {
//     std::string name;
//     int age;

//     bool operator<(const Person& other) const {
//         return age < other.age;
//     }

//     bool operator==(const Person& other) const {
//         return name == other.name;
//     }
// };

// int main() {
//     boost::container::flat_map<std::string, Person> people;
    
//     people["Alice"] = {"Alice", 30};
//     people["Bob"] = {"Bob", 25};
    
//     for (const auto& pair : people) {
//         std::cout << pair.first << ": " << pair.second.age << " years old\n";
//     }

//     return 0;
// }


//////////////////////////////////////////////////
//5. 侵入式容器
/////////////////////////////////////////////////

// struct MyStruct : public boost::intrusive::list_base_hook<> {
//     int value;

//     MyStruct(int val) : value(val) {}
// };

// int main() {
//     boost::intrusive::list<MyStruct> list;
    
//     MyStruct a(10), b(20), c(30);
//     list.push_back(a);
//     list.push_back(b);
//     list.push_back(c);
    
//     for (auto& element : list) {
//         std::cout << element.value << " ";
//     }
//     std::cout << std::endl;

//     return 0;
// }



//////////////////////////////////////////////////
//6. 扁平容器
/////////////////////////////////////////////////

// int main() {
//     boost::container::flat_map<int, std::string> flatMap;
//     flatMap[1] = "One";
//     flatMap[2] = "Two";
//     flatMap[3] = "Three";
    
//     for (const auto& pair : flatMap) {
//         std::cout << pair.first << ": " << pair.second << std::endl;
//     }

//     return 0;
// }

